<!doctype html><html lang=cn-zh><head><meta charset=UTF-8><meta name=viewport content="width=device-width,initial-scale=1"><meta http-equiv=X-UA-Compatible content="IE=edge"><style type=text/css>body{font-family:monospace}</style><title>[译]关于python字典类型最疯狂的表达方式</title>
<meta name=description content="A blog maintained by Vimiix."><link rel=stylesheet href=/css/style.css><script>var _hmt=_hmt||[];(function(){var e,t=document.createElement("script");t.src="https://hm.baidu.com/hm.js?7c24231917964240bae97e813810620c",e=document.getElementsByTagName("script")[0],e.parentNode.insertBefore(t,e)})()</script></head><body><header>====================<br>== Hi, I'm Vimiix ==<br>====================<div style=float:right;color:gray;font-size:x-large>Get hands dirty.</div><br><p><nav><a href=https://www.vimiix.com/><b>首页</b></a>.
<a href=/posts/><b>文章列表</b></a>.
<a href=/projects/><b>开源项目</b></a>.
<a href=/tags/><b>标签</b></a>.
<a href=/friends/><b>友链</b></a>.
<a href=/about/><b>关于我</b></a>.
<a href=/index.xml><b>RSS</b></a>.</nav></p></header><main><article><h1>[译]关于python字典类型最疯狂的表达方式</h1><b><time>2017.12.28 10:31</time></b>
<a href=/tags/python>Python</a>
<a href=/tags/translation>translation</a>
<a href=/tags/dict>dict</a>
<a href=/tags/trick>trick</a><div><p><a href=https://juejin.im/post/5a4459b05188257d6a7ed76b><figure><img src="https://badge.juejin.im/entry/5a4459c9f265da43112080ea/likes.svg?style=flat-square" alt></figure></a></p><blockquote><p>一篇来自 <a href=https://dbader.org/blog/python-mystery-dict-expression>Dan Bader</a> 的有趣的博文，一起来学习一下，如何去研究一个意外的 Python 现象。</p></blockquote><h2 id=一个-python-字典表达式谜题>一个 Python 字典表达式谜题</h2><p>让我们探究一下下面这个晦涩的 python 字典表达式，以找出在 python 解释器的中未知的内部到底发生了什么。</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#75715e># 一个python谜题：这是一个秘密</span>
</span></span><span style=display:flex><span><span style=color:#75715e># 这个表达式计算以后会得到什么结果？</span>
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> {<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;yes&#39;</span>, <span style=color:#ae81ff>1</span>: <span style=color:#e6db74>&#39;no&#39;</span>, <span style=color:#ae81ff>1.0</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span></code></pre></div><p>有时候你会碰到一个很有深度的代码示例 &mdash; 哪怕仅仅是一行代码，但是如果你能够有足够的思考，它可以教会你很多关于编程语言的知识。这样一个代码片段，就像是一个*<code>Zen kōan</code>*：一个在修行的过程中用来质疑和考验学生进步的问题或陈述。</p><p><em>译者注：<code>Zen kōan</code>,大概就是修行的一种方式，详情见<a href=https://en.wikipedia.org/wiki/K%C5%8Dan>wikipedia</a></em></p><p>我们将在本教程中讨论的小代码片段就是这样一个例子。乍看之下，它可能看起来像一个简单的词典表达式，但是仔细考虑时，通过 cpython 解释器，它会带你进行一次思维拓展的训练。</p><p>我从这个短短的一行代码中得到了一个启发，而且有一次在我参加的一个 Python 会议上，我还把作为我演讲的内容，并以此开始演讲。这也激发了我的 python 邮件列表成员间进行了一些积极的交流。</p><p>所以不用多说，就是这个代码片。花点时间思考一下下面的字典表达式，以及它计算后将得到的内容：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> {<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;yes&#39;</span>, <span style=color:#ae81ff>1</span>: <span style=color:#e6db74>&#39;no&#39;</span>, <span style=color:#ae81ff>1.0</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span></code></pre></div><p>在这里,我先等会儿，大家思考一下&mldr;</p><ul><li>5&mldr;</li><li>4&mldr;</li><li>3&mldr;</li><li>2&mldr;</li><li>1&mldr;</li></ul><hr><p>OK, 好了吗？</p><p>这是在 cpython 解释器交互界面中计算上述字典表达式时得到的结果：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> {<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;yes&#39;</span>, <span style=color:#ae81ff>1</span>: <span style=color:#e6db74>&#39;no&#39;</span>, <span style=color:#ae81ff>1.0</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span><span style=display:flex><span>{<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span></code></pre></div><p>我承认，当我第一次看到这个结果时，我很惊讶。但是当你逐步研究其中发生的过程时，这一切都是有道理的。所以，让我们思考一下为什么我们得到这个 - <em>我想说的是出乎意料</em> - 的结果。</p><h2 id=这个子字典是从哪里来的>这个子字典是从哪里来的</h2><p>当 python 处理我们的字典表达式时，它首先构造一个新的空字典对象;然后按照字典表达式给出的顺序赋键和值。</p><p>因此，当我们把它分解开的时候，我们的字典表达就相当于这个顺序的语句：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> xs <span style=color:#f92672>=</span> dict()
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> xs[<span style=color:#66d9ef>True</span>] <span style=color:#f92672>=</span> <span style=color:#e6db74>&#39;yes&#39;</span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> xs[<span style=color:#ae81ff>1</span>] <span style=color:#f92672>=</span> <span style=color:#e6db74>&#39;no&#39;</span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> xs[<span style=color:#ae81ff>1.0</span>] <span style=color:#f92672>=</span> <span style=color:#e6db74>&#39;maybe&#39;</span>
</span></span></code></pre></div><p>奇怪的是，Python 认为在这个例子中使用的所有字典键是相等的：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> <span style=color:#66d9ef>True</span> <span style=color:#f92672>==</span> <span style=color:#ae81ff>1</span> <span style=color:#f92672>==</span> <span style=color:#ae81ff>1.0</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>True</span>
</span></span></code></pre></div><p>OK，但在这里等一下。我确定你能够接受 1.0 == 1，但实际情况是为什么<code>True</code>也会被认为等于 1 呢？我第一次看到这个字典表达式真的让我难住了。</p><p>在 python 文档中进行一些探索之后，我发现 python 将<code>bool</code>作为了<code>int</code>类型的一个子类。这是在 Python 2 和 Python 3 的片段：</p><blockquote><p>“The Boolean type is a subtype of the integer type, and Boolean values behave like the values 0 and 1, respectively, in almost all contexts, the exception being that when converted to a string, the strings ‘False’ or ‘True’ are returned, respectively.”</p><p>“布尔类型是整数类型的一个子类型，在几乎所有的上下文环境中布尔值的行为类似于值 0 和 1，例外的是当转换为字符串时，会分别将字符串”False“或”True“返回。“（<a href=https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy>原文</a>）</p></blockquote><p>是的，这意味着你可以在编程时上使用<code>bool</code>值作为 Python 中的列表或元组的索引：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> [<span style=color:#e6db74>&#39;no&#39;</span>, <span style=color:#e6db74>&#39;yes&#39;</span>][<span style=color:#66d9ef>True</span>]
</span></span><span style=display:flex><span><span style=color:#e6db74>&#39;yes&#39;</span>
</span></span></code></pre></div><p>但为了代码的可读性起见，您不应该类似这样的来使用布尔变量。（也请建议你的同事别这样做）</p><p>Anyway，让我们回过来看我们的字典表达式。</p><p>就 python 而言，<code>True</code>，<code>1</code>和<code>1.0</code>都表示相同的字典键。当解释器计算字典表达式时，它会重复覆盖键<code>True</code>的值。这就解释了为什么最终产生的字典只包含一个键。</p><p>在我们继续之前，让我们再回顾一下原始字典表达式：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> {<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;yes&#39;</span>, <span style=color:#ae81ff>1</span>: <span style=color:#e6db74>&#39;no&#39;</span>, <span style=color:#ae81ff>1.0</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span><span style=display:flex><span>{<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span></code></pre></div><p>这里为什么最终得到的结果是以<code>True</code>作为键呢？由于重复的赋值，最后不应该是把键也改为<code>1.0</code>了？经过对 cpython 解释器源代码的一些模式研究，我知道了，当一个新的值与字典的键关联的时候，python 的字典不会更新键对象本身：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> ys <span style=color:#f92672>=</span> {<span style=color:#ae81ff>1.0</span>: <span style=color:#e6db74>&#39;no&#39;</span>}
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> ys[<span style=color:#66d9ef>True</span>] <span style=color:#f92672>=</span> <span style=color:#e6db74>&#39;yes&#39;</span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> ys
</span></span><span style=display:flex><span>{<span style=color:#ae81ff>1.0</span>: <span style=color:#e6db74>&#39;yes&#39;</span>}
</span></span></code></pre></div><p>当然这个作为性能优化来说是有意义的 &mdash; 如果键被认为是相同的，那么为什么要花时间更新原来的？在最开始的例子中，你也可以看到最初的<code>True</code>对象一直都没有被替换。因此，字典的字符串表示仍然打印为以<code>True</code>为键（而不是 1 或 1.0）。</p><p>就目前我们所知而言，似乎看起来像是，结果中字典的值一直被覆盖，只是因为他们的键比较后相等。然而，事实上，这个结果也不单单是由<code>__eq__</code>比较后相等就得出的。</p><h2 id=等等那哈希值呢>等等，那哈希值呢？</h2><p>python 字典类型是由一个哈希表数据结构存储的。当我第一次看到这个令人惊讶的字典表达式时，我的直觉是这个结果与散列冲突有关。</p><p>哈希表中键的存储是根据每个键的哈希值的不同，包含在不同的“buckets”中。哈希值是指根据每个字典的键生成的一个固定长度的数字串，用来标识每个不同的键。（<a href=https://zh.wikipedia.org/wiki/%E6%95%A3%E5%88%97%E5%87%BD%E6%95%B8>哈希函数详情</a>）</p><p>这可以实现快速查找。在哈希表中搜索键对应的哈希数字串会快很多，而不是将完整的键对象与所有其他键进行比较，来检查互异性。</p><p>然而，通常计算哈希值的方式并不完美。并且，实际上会出现不同的两个或更多个键会生成相同的哈希值，并且它们最后会出现在相同的哈希表中。</p><p>如果两个键具有相同的哈希值，那就称为<em>哈希冲突(hash collision)</em>，这是在哈希表插入和查找元素时需要处理的特殊情况。</p><p>基于这个结论，哈希值与我们从字典表达中得到的令人意外的结果有很大关系。所以让我们来看看键的哈希值是否也在这里起作用。</p><p>我定义了这样一个类来作为我们的测试工具：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#66d9ef>class</span> <span style=color:#a6e22e>AlwaysEquals</span>:
</span></span><span style=display:flex><span>     <span style=color:#66d9ef>def</span> __eq__(self, other):
</span></span><span style=display:flex><span>         <span style=color:#66d9ef>return</span> <span style=color:#66d9ef>True</span>
</span></span><span style=display:flex><span>
</span></span><span style=display:flex><span>     <span style=color:#66d9ef>def</span> __hash__(self):
</span></span><span style=display:flex><span>         <span style=color:#66d9ef>return</span> id(self)
</span></span></code></pre></div><p>这个类有两个特别之处。</p><p>第一，因为它的<code>__eq__</code>魔术方法（<em>译者注：双下划线开头双下划线结尾的是一些 Python 的“魔术”对象</em>）总是返回 true，所以这个类的所有实例和其他任何对象都会恒等：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> AlwaysEquals() <span style=color:#f92672>==</span> AlwaysEquals()
</span></span><span style=display:flex><span><span style=color:#66d9ef>True</span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> AlwaysEquals() <span style=color:#f92672>==</span> <span style=color:#ae81ff>42</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>True</span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> AlwaysEquals() <span style=color:#f92672>==</span> <span style=color:#e6db74>&#39;waaat?&#39;</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>True</span>
</span></span></code></pre></div><p>第二，每个<code>Alwaysequals</code>实例也将返回由内置函数<code>id()</code>生成的唯一哈希值值：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> objects <span style=color:#f92672>=</span> [AlwaysEquals(),
</span></span><span style=display:flex><span>               AlwaysEquals(),
</span></span><span style=display:flex><span>               AlwaysEquals()]
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> [hash(obj) <span style=color:#66d9ef>for</span> obj <span style=color:#f92672>in</span> objects]
</span></span><span style=display:flex><span>[<span style=color:#ae81ff>4574298968</span>, <span style=color:#ae81ff>4574287912</span>, <span style=color:#ae81ff>4574287072</span>]
</span></span></code></pre></div><p>在 CPython 中，<code>id()</code>函数返回的是一个对象在内存中的地址，并且是确定唯一的。</p><p>通过这个类，我们现在可以创建看上去与其他任何对象相同的对象，但它们都具有不同的哈希值。我们就可以通过这个来测试字典的键是否是基于它们的相等性比较结果来覆盖。</p><p>正如你所看到的，下面的一个例子中的键不会被覆盖，即使它们总是相等的：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> {AlwaysEquals(): <span style=color:#e6db74>&#39;yes&#39;</span>, AlwaysEquals(): <span style=color:#e6db74>&#39;no&#39;</span>}
</span></span><span style=display:flex><span>{ <span style=color:#f92672>&lt;</span>AlwaysEquals object at <span style=color:#ae81ff>0x110a3c588</span><span style=color:#f92672>&gt;</span>: <span style=color:#e6db74>&#39;yes&#39;</span>,
</span></span><span style=display:flex><span>  <span style=color:#f92672>&lt;</span>AlwaysEquals object at <span style=color:#ae81ff>0x110a3cf98</span><span style=color:#f92672>&gt;</span>: <span style=color:#e6db74>&#39;no&#39;</span> }
</span></span></code></pre></div><p>下面，我们可以换个思路，如果返回相同的哈希值是不是就会让键被覆盖呢？</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#66d9ef>class</span> <span style=color:#a6e22e>SameHash</span>:
</span></span><span style=display:flex><span>    <span style=color:#66d9ef>def</span> __hash__(self):
</span></span><span style=display:flex><span>        <span style=color:#66d9ef>return</span> <span style=color:#ae81ff>1</span>
</span></span></code></pre></div><p>这个<code>SameHash</code>类的实例将相互比较一定不相等，但它们会拥有相同的哈希值 1：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> a <span style=color:#f92672>=</span> SameHash()
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> b <span style=color:#f92672>=</span> SameHash()
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> a <span style=color:#f92672>==</span> b
</span></span><span style=display:flex><span><span style=color:#66d9ef>False</span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> hash(a), hash(b)
</span></span><span style=display:flex><span>(<span style=color:#ae81ff>1</span>, <span style=color:#ae81ff>1</span>)
</span></span></code></pre></div><p>一起来看看 python 的字典在我们试图使用<code>SameHash</code>类的实例作为字典键时的结果：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> {a: <span style=color:#e6db74>&#39;a&#39;</span>, b: <span style=color:#e6db74>&#39;b&#39;</span>}
</span></span><span style=display:flex><span>{ <span style=color:#f92672>&lt;</span>SameHash instance at <span style=color:#ae81ff>0x7f7159020cb0</span><span style=color:#f92672>&gt;</span>: <span style=color:#e6db74>&#39;a&#39;</span>,
</span></span><span style=display:flex><span>  <span style=color:#f92672>&lt;</span>SameHash instance at <span style=color:#ae81ff>0x7f7159020cf8</span><span style=color:#f92672>&gt;</span>: <span style=color:#e6db74>&#39;b&#39;</span> }
</span></span></code></pre></div><p>如本例所示，“键被覆盖”的结果也并不是单独由哈希冲突引起的。</p><h2 id=umm好吧可以得到什么结论呢>Umm..好吧,可以得到什么结论呢?</h2><p>检查 python 字典对象中两个 key 是否相同的条件是：<strong>二者的相等性(__eq__)以及 hash 值对比(__hash__)是否相等</strong>。那我们就来总结一下上述讨论的结果：</p><p><code>{true：'yes'，1：'no'，1.0：'maybe'}</code> 字典表达式计算结果为 <code>{true：'maybe'}</code>，是因为键 <code>true</code>，<code>1</code> 和 <code>1.0</code> 都是相等的，并且它们都有相同的哈希值：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> <span style=color:#66d9ef>True</span> <span style=color:#f92672>==</span> <span style=color:#ae81ff>1</span> <span style=color:#f92672>==</span> <span style=color:#ae81ff>1.0</span>
</span></span><span style=display:flex><span><span style=color:#66d9ef>True</span>
</span></span><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> (hash(<span style=color:#66d9ef>True</span>), hash(<span style=color:#ae81ff>1</span>), hash(<span style=color:#ae81ff>1.0</span>))
</span></span><span style=display:flex><span>(<span style=color:#ae81ff>1</span>, <span style=color:#ae81ff>1</span>, <span style=color:#ae81ff>1</span>)
</span></span></code></pre></div><p>也许并不那么令人惊讶，这就是我们为何得到这个结果作为字典的最终结果的原因：</p><div class=highlight><pre tabindex=0 style=color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4><code class=language-python data-lang=python><span style=display:flex><span><span style=color:#f92672>&gt;&gt;&gt;</span> {<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;yes&#39;</span>, <span style=color:#ae81ff>1</span>: <span style=color:#e6db74>&#39;no&#39;</span>, <span style=color:#ae81ff>1.0</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span><span style=display:flex><span>{<span style=color:#66d9ef>True</span>: <span style=color:#e6db74>&#39;maybe&#39;</span>}
</span></span></code></pre></div><p>我们在这里涉及了很多方面内容，而这个特殊的 python 技巧起初可能有点令人难以置信 &mdash; 所以我一开始就把它比作是<code>Zen kōan</code>。</p><p>如果很难理解本文中的内容，请尝试在 Python 交互环境中逐个去检验一下代码示例。你会收获一些关于 python 深处知识。</p><blockquote><p><strong>注：转载请保留下面的内容</strong></p><p>原文链接：<a href=https://dbader.org/blog/python-mystery-dict-expression>https://dbader.org/blog/python-mystery-dict-expression</a></p><p>译文链接：<a href=http://vimiix.com/post/2017/12/28/python-mystery-dict-expression/>http://vimiix.com/post/2017/12/28/python-mystery-dict-expression/</a></p></blockquote></div></article></main><aside><div><div><h3>LATEST POSTS</h3></div><div><ul><li><a href=/posts/2025-10-16-kubernetes-apiserver-authorization-mechanism/>Kubernetes APIServer 鉴权机制</a></li><li><a href=/posts/2025-09-30-kubernetes-apiserver-authentication-mechanism/>Kubernetes APIServer 认证机制</a></li><li><a href=/posts/2024-12-16-deploy-kubernetes-by-kubeadm/>使用 kubeadm 搭建 kubernetes 集群</a></li><li><a href=/posts/2024-09-20-how-to-code-review/>如何做code review</a></li><li><a href=/posts/2024-08-12-weakref-in-python/>Python中的弱引用</a></li></ul></div></div></aside><footer><p>Social Links:
<a href=https://github.com/vimiix><b>Github</b></a>.
<a href=https://www.douban.com/people/vimiix/><b>Douban</b></a>.
<a href=mailto:i@vimiix.com><b>Email</b></a>.<br><hr>&copy; 2017-2025
Vimiix Yao; All rights reserved.
<a href=https://beian.miit.gov.cn/>京ICP备19015214号-1</a></p><script src=https://l2dwidget.js.org/lib/L2Dwidget.min.js></script><script>L2Dwidget.init({model:{jsonPath:"https://unpkg.com/live2d-widget-model-tororo@1.0.5/assets/tororo.model.json"}})</script></footer></body></html>